



import bpy
from bpy.types import Operator
from 全局控制.Node.节点和插座基类.bl_UpdateNode import *
from 全局控制.Node.节点和插座基类 import bl_容器节点 as 容器
import 全局控制.Node.节点和插座基类.bl_节点基类 as 基类
import 全局控制.Node.插座.bl_插座基类 as 插件基类
#import 全局控制.Node.节点和插座基类.bl_UpdateNode as 节点插座查找

import pdb


g_迭代器元素 = {}


class C_NodeSocket_循环迭代器(插件基类.C_NodeSocket_基类):
	bl_label = '迭代元素'
	name = '迭代元素'
	
	m_迭代索引 = 0
	
	def __init__(self):
		super(C_NodeSocket_循环迭代器, self).__init__()

	def draw(self, context, layout, node, text):
		#if self.m_迭代索引 != None :
		#	layout.label(text=self.name + ':' + str(self.m_迭代索引) )
		#else:
		info = '迭代器:'
		if len(g_迭代器元素) :
			info += str(g_迭代器元素[self.id_data.name + self.name])
		layout.label(text = info )

	
	def f_getData(self, key=-1):
		super(C_NodeSocket_循环迭代器, self).f_getData(key)
		global g_迭代器元素
		return g_迭代器元素[self.id_data.name + self.name]

	def f_setData(self, data):
		global g_迭代器元素
		super(C_NodeSocket_循环迭代器, self).f_setData(data)
		g_迭代器元素[self.id_data.name + self.name] = data
		
		



class C_SN_循环迭代器(基类.C_SN_基类):
	bl_label = '__node_循环迭代器__'
	bl_dname = 'bl_node_迭代器'
	
	m_是否区间 = bpy.props.BoolProperty(name='区间', default=False)
	#m_Back = bpy.props.BoolProperty(name='back', default=False)
	def init(self, context):
		super(C_SN_循环迭代器, self).f_init(context)
		#self.name = '__node_循环迭代器__'
		self.use_custom_color = True
		self.color = (1.0, 1.0, 0.0)

		self.inputs.new('C_NodeSocket_引用', name='迭代列表')
		self.outputs.new('C_NodeSocket_循环迭代器', name='迭代元素')
		self.outputs.new('C_NodeSocket_i', name='索引')
		self.outputs.new('C_NodeSocket_i', name='次数')
		
		
	def draw_buttons(self, context, layout):
		layout.prop(self, 'm_是否区间')
	def update(self):
		print('update C_SN_循环判断条件')

	def f_update(self, 是否向下传递=False, input插座=None):
		super(C_SN_循环迭代器, self).f_update(是否向下传递, input插座)
		return False
		#print('循环迭代器更新', self.name)
		
	def f_is强制Update(self):
		return True

	def f_get循环列表(self):
		外部输入插座 = f_get上一层Output插座(self.inputs['迭代列表'])
		
		if 外部输入插座 :
			#print('当前所在树_上层树 外部输入插座 = ', 外部输入插座)
			if 外部输入插座 :
				#print('外部输入插座 = ', 输入节点输出插座.name, 外部输入插座)
				data = 外部输入插座.f_getData()
				self.f_标记为已更新()

				是否while = 0
				if type(data).__name__ == 'bool':
					是否while = 'while'

				elif type(data).__name__ == 'list':
					#print('type(data[0]) = ', type(data).__name__, len(data))
					num = len(data)
					if num == 2 and self.m_是否区间:
						是否while = '区间'
					else:
						是否while = '迭代元素'

				elif type(data).__name__ == 'int':
					是否while = '固定'
					
				if data == None :
					data = False
					是否while = 'while'
				return data, 是否while

		return False, 'while'

class C_NODE_AddMenu_循环迭代器(bpy.types.Operator):
	bl_idname = 'node.global_node_iterator'
	bl_label = '循环迭代器'
	bl_options = {'REGISTER', 'UNDO'}
	
	def execute(operator, context):
		node = bpy.ops.node.add_node(type='C_SN_循环迭代器', use_transform=True)
		return {'FINISHED'}






class C_SceneNode_循环(容器.C_SceneNode_容器): 
	bl_label = '循环'
	bl_dname = 'bl_node_循环'
	
	def init(self, context):
		super(C_SceneNode_循环, self).init(context)
		self.use_custom_color = True
		self.color = (0.6, 0.2, 0.6)
		
		#创建循环条件节点
		循环条件_node = self.node_tree.nodes.new(type='C_SN_循环迭代器')
		循环条件_node.name = "__node_循环迭代器__"
		#context.space_data.path.append(self.node_tree)
		
	def f_进入子集(self):
		super(C_SceneNode_循环, self).f_进入子集()

	#def draw_buttons(self, context, layout):
	#	layout.prop(self, 'm_运算类型')
	#def update(self):
	#	print('self.m_当前所在树 = ', type(self.node_tree), self.node_tree)
	def f_input插座Update(self, input插座, 上层Output=None):
		#print('f_input插座Update = ', self.idname)
		super(C_SceneNode_循环, self).f_input插座Update(input插座, 上层Output)
		

	def f_update(self, 是否向下传递=False, input插座=None):
		#pdb.set_trace()
		循环判断条件节点 = self.node_tree.nodes['__node_循环迭代器__']
		r, 是否while = 循环判断条件节点.f_get循环列表()

		
		#print('r = ', r, 是否while, dir(循环判断条件节点.outputs['迭代元素']))
		迭代Index = 0
		if 是否while == 'while' :
			循环判断条件节点.outputs['次数'].f_setData(int(r))
			while r :
				循环判断条件节点.outputs['迭代元素'].f_setData(迭代Index)
				循环判断条件节点.outputs['索引'].f_setData(迭代Index)
				print('r A ===== ', r, 迭代Index)
				迭代Index += 1
				if super(C_SceneNode_循环, self).f_update(是否向下传递, input插座) :
					
					return True

		elif 是否while == '区间':
			循环判断条件节点.outputs['次数'].f_setData(int(r[1]) - int(r[0]))
			for i in range(int(r[0]), int(r[1])) :
				循环判断条件节点.outputs['迭代元素'].f_setData(i)
				循环判断条件节点.outputs['索引'].f_setData(迭代Index)
				print('r B ===== ', r, 迭代Index)
				if super(C_SceneNode_循环, self).f_update(是否向下传递, input插座) :
					return True
				迭代Index += 1

		elif 是否while == '固定':
			循环判断条件节点.outputs['次数'].f_setData(int(r))
			for i in range(int(r)) :
				循环判断条件节点.outputs['迭代元素'].f_setData(i)
				循环判断条件节点.outputs['索引'].f_setData(迭代Index)
				print('r B ===== ', r, 迭代Index)
				if super(C_SceneNode_循环, self).f_update(是否向下传递, input插座) :
					return True
				迭代Index += 1
		else:
			循环判断条件节点.outputs['次数'].f_setData(len(r))
			for i in r :
				循环判断条件节点.outputs['迭代元素'].f_setData(i)
				循环判断条件节点.outputs['索引'].f_setData(迭代Index)
				print('r B ===== ', r, 迭代Index)
				if super(C_SceneNode_循环, self).f_update(是否向下传递, input插座) :
					return True
				迭代Index += 1
		
		return False
		#self.outputs[0].f_setData(value)
		#self.f_标记为已更新()

class C_NODE_AddMenu_循环(bpy.types.Operator):
	bl_idname = 'node.global_node_loop'
	bl_label = 'Add 循环节点'
	bl_options = {'REGISTER', 'UNDO'}
	
	def execute(operator, context):
		node = bpy.ops.node.add_node(type='C_SceneNode_循环', use_transform=True)
		return {'FINISHED'}

	






class C_SN_跳出循环(基类.C_SN_基类): 
	bl_dname = 'bl_node_跳出循环'
	bl_label = '跳出循环'
	
	def init(self, context):
		super(C_SN_跳出循环, self).f_init(context)
		self.use_custom_color = True
		self.color = (0.6, 0.2, 0.6)

	def f_update(self, 是否向下传递=False, input插座=None):
		super(C_SN_跳出循环, self).f_update(是否向下传递, input插座)
		print('self back == ', self)
		return True
		
		
class C_NODE_AddMenu_跳出循环(bpy.types.Operator):
	bl_idname = 'node.global_node_back'
	bl_label = '跳出循环节点'
	bl_options = {'REGISTER', 'UNDO'}

	def execute(operator, context):
		node = bpy.ops.node.add_node(type='C_SN_跳出循环', use_transform=True)
		
		return {'FINISHED'}



classes = (
	C_NodeSocket_循环迭代器,
	C_SN_循环迭代器,
	C_NODE_AddMenu_循环迭代器,

	C_SceneNode_循环,
	C_NODE_AddMenu_循环,
	
	C_SN_跳出循环,
	C_NODE_AddMenu_跳出循环,
)




def register():
	for c in classes:
		bpy.utils.register_class(c)
		
	#bpy.types.NodeInternal.m_当前所在树 = bpy.props.PointerProperty(name='物体控制节点树', type=bpy.types.NodeTree)


def unregister():
	for c in classes:
		bpy.utils.unregister_class(c)

	

